package zhenniu.best.webview.zhenniuwebview.ui.activity;

import android.content.DialogInterface;
import android.content.Intent;

import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.NonNull;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v4.view.animation.FastOutSlowInInterpolator;
import android.text.TextUtils;
import android.util.Base64;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;


import com.blankj.utilcode.constant.PermissionConstants;
import com.blankj.utilcode.util.PermissionUtils;
import com.blankj.utilcode.util.SPUtils;
import com.blankj.utilcode.util.SizeUtils;
import com.bumptech.glide.Glide;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.timmy.tdialog.TDialog;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import butterknife.BindView;
import butterknife.ButterKnife;
import fr.castorflex.android.smoothprogressbar.SmoothProgressBar;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import retrofit2.converter.gson.GsonConverterFactory;
import zhenniu.best.webview.zhenniuwebview.R;
import zhenniu.best.webview.zhenniuwebview.ZhenNiu;
import zhenniu.best.webview.zhenniuwebview.bean.MessageEvent;
import zhenniu.best.webview.zhenniuwebview.bean.VersionBean;
import zhenniu.best.webview.zhenniuwebview.bean.VersionEncryptBean;
import zhenniu.best.webview.zhenniuwebview.bean.VersionJsonBean;
import zhenniu.best.webview.zhenniuwebview.global.Constants;
import zhenniu.best.webview.zhenniuwebview.network.Network;
import zhenniu.best.webview.zhenniuwebview.network.Retrofit_RequestUtils;
import zhenniu.best.webview.zhenniuwebview.ui.view.BaseDialog;
import zhenniu.best.webview.zhenniuwebview.utils.AppUtils;
import zhenniu.best.webview.zhenniuwebview.utils.DecryptUtil;
import zhenniu.best.webview.zhenniuwebview.utils.DownloadUtils;


//</editor-fold>
//<editor-fold desc= "登录界面">
public class LaunchActivity extends BaseActivity {


    @BindView(R.id.vp_launch)
    ViewPager mVpLaunch;
    @BindView(R.id.ll_launch_indicator)
    LinearLayout mLlLaunchIndicator;
    @BindView(R.id.btn_launch_into_app)
    Button mBtnLaunch;
    private LaunchActivity mContext;
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };
    //bean
    private VersionBean mVersionBean;
    //是否按了确定按钮
    public boolean isSure = false;
    //是否按了取消按钮
    private boolean isCancel = false;
    //引导页图片集合
    private int[] imgs;
    //banner轮播图的图片集合
    private ArrayList<ImageView> imageViews;
    //当前滑到第几页
    private int prePosition;
    private TDialog tDialog;
    //升级更新弹窗
    private BaseDialog baseDialog;
    private Button bt2;
    private SmoothProgressBar mProgressBar;
    private TextView tv_next_time;
    //普通或强制更新，跳到安装界面，点击取消安装再跳回本应用时，升级弹窗是否会被取消的标志位
    private boolean isUpdateDismiss = false;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //根据是否是首次进来去设置不同的主题，非第一次进入app设置的是带有背景图片的主题，而第一次是没有的
        setTheme(/*ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true)*/false ? R.style.StartAppThemeNoBg : R.style.StartAppTheme);
        setContentView(R.layout.activity_launch);
        ButterKnife.bind(this);
        init();
        setListener();
    }

    private void init() {
        mContext = this;
        ZhenNiu.addActivity(this);

        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                //请求权限,包含电话权限（获取IMEI）
                if (Build.VERSION.SDK_INT >= 23) {
                    requestPermission();

                } else {   //低于23版本
                    //获取版本
                    getVersionFromPhp();
                }
            }
        }, 1000);


        //判断是否是第一次进来
//        if (ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true/*false*/)) {   // 第一次使用APP，在第三页申请权限以及版本判断
//            //延迟进入引导页
//            mHandler.postDelayed(new Runnable() {
//                @Override
//                public void run() {
//                    // 初始化引导页
//                    initImageAndIndicator();
//                    initViewPager();
//                }
//            }, 1000);
//
//        } else {   // 非第一次使用APP
//            //请求权限,包含电话权限（获取IMEI）
//            if (Build.VERSION.SDK_INT >= 23) {
//                requestPermission();
//
//            } else {   //低于23版本
//                //获取版本
//                getVersionFromPhp();
//
//            }
//        }

    }

    private void setListener() {
        //权限弹窗按钮监听
        setPermissionTDListener(new PermissionTDListener() {
            @Override
            public void permissionCancel() {
//                if (!ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true/*false*/)) {   // 非第一次使用APP，从设置权限页面回来后，会调用initPage（）
//                    //跳转到设置界面的弹窗被点击取消
//                    initPage();
//                }
                //跳转到设置界面的弹窗被点击取消
                initPage();
                isCancel = true;
            }

            @Override
            public void permissionSure() {
                //确定转到设置界面后,再回到这个页面会调用onrestart方法
                isSure = true;
            }

            @Override
            public void permissionDismiss() {
                //问题
                //1、按返回键，取消跳转到设置界面，也会走这个方法
                //2、按确定键，跳到设置界面也会走这个方法，然后从设置界面回来，调用restart生命方法，再次走这个方法，导致走两次

                //如果是按返回键致使dialog消失，那么就走 initPage()方法
                //isCancel || isSure 是true就代表用户按了取消或者确定键，此时就不走这个方法里的initPage()
                if (!(isCancel || isSure) /*&& !ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true)*/) {
                    initPage();
                }
            }
        });
    }


    /**
     * 请求权限
     */
    private void requestPermission() {
        PermissionUtils.permission(PermissionConstants.STORAGE).callback(new PermissionUtils.SimpleCallback() {
            @Override
            public void onGranted() {
//                if (!ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true)) {   // 非第一次使用APP，才判断是否升级版本
//                    //所有权限都同意后才获取版本
//                    getVersionFromPhp();
//                }
                //所有权限都同意后才获取版本
                getVersionFromPhp();
            }

            @Override
            public void onDenied() {
                showTipsDialog();
            }
        }).request();
    }

    /**
     * 获得本地版本
     */
    private String getLocalVerson() {

        return AppUtils.getAppVersionName();
    }

    /**
     * 从后台获取最新版本
     * 1、发现如果有新版本，对话框提示更新  1）确定 则跟新    2）不确定 则进入首页
     * 2、版本是最新 则进入initPage方法，判断是否是第一次登录
     * 2、如果网络出错，进入首页
     */
    private void getVersionFromPhp() {
        //版本号
        String[] split = AppUtils.getAppVersionName().split("\\.");
        StringBuilder stringVersion = new StringBuilder();
        for (String s : split) {
            stringVersion.append(s);
        }
        //转成json格式
        String s =  new Gson().toJson(new VersionJsonBean("0", stringVersion.toString()));

        RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),s);

        Retrofit_RequestUtils.getRequest(Network.VERSIONURL)
                .updateVersion(body)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<JsonObject>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(JsonObject jsonObject) {

                        //转成解密bean类型
                        VersionEncryptBean versionEncryptBean = new Gson().fromJson(jsonObject.toString(), VersionEncryptBean.class);

                        try {
                            //解密
                            String result = DecryptUtil.base64Asedecrypt(versionEncryptBean.getEnctyptData(), Cipher.DECRYPT_MODE);
                            mVersionBean = new Gson().fromJson(result, VersionBean.class);

                            //请求成功
                            if (mVersionBean.getResCode().equals(Constants.SUCCESS_CODE)) {
                                if (mVersionBean.getData() != null) {   //版本升级
                                    Constants.LATEST_VERSION = false;
                                    showDialogUpdata();
                                    //更新文案
                                    ZhenNiu.spUtils.put(Constants.VERSION_CONTENT, mVersionBean.getData().getChangeCopywriting());
                                    ZhenNiu.spUtils.put(Constants.VERSION_NAME, mVersionBean.getData().getVersionNumber());

                                } else {   //不需要版本升级，直接初始化页面
                                    initPage();
                                    Constants.LATEST_VERSION = true;
                                }
                            } else {
                                initPage();
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            initPage();
                        }

                    }

                    @Override
                    public void onError(Throwable e) {
                        initPage();
                    }

                    @Override
                    public void onComplete() {

                    }
                });

        //初始化更新弹窗
//        initUpdateDialog();
//        initPage();
    }


    /**
     * 接收当前的下载进度值
     * @param event
     */
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void progressBar(MessageEvent event) {
        //跳转到下一页
        if (event.getI() == 100) {
            mProgressBar.setVisibility(View.GONE);
            mProgressBar.progressiveStop();
            bt2.setVisibility(View.VISIBLE);
            bt2.setText("升级");
        }
    }

    /**
     * 版本更新弹窗
     */
    public void showDialogUpdata(){
        baseDialog = new BaseDialog(this, R.style.BaseDialog, R.layout.dialog_custom_version_layout);
        TextView textView = baseDialog.findViewById(R.id.tv_msg);
        bt2 = baseDialog.findViewById(R.id.version_dialog_commit);
        mProgressBar = baseDialog.findViewById(R.id.progressbar);
        tv_next_time = baseDialog.findViewById(R.id.tv_next_time);

        if (mVersionBean != null && mVersionBean.getData() != null) {
            String enforceUpdate = String.valueOf(mVersionBean.getData().getChangeProperties());
            //TODO 根据后台返回判断是否显示“下次再说”字样
            if (mVersionBean != null && !TextUtils.isEmpty(enforceUpdate)) {
                //是否强更（1、否，2、是）
                if ("1".equals(enforceUpdate)) {
                    tv_next_time.setVisibility(View.VISIBLE);
                    isUpdateDismiss = true;
                }else {
                    tv_next_time.setVisibility(View.GONE);
                    isUpdateDismiss = false;
                }
            }
            //升级文字
            if (mVersionBean != null && !TextUtils.isEmpty(mVersionBean.getData().getChangeCopywriting())) {
                textView.setText(mVersionBean.getData().getChangeCopywriting());
            }
            //下载进度条设置
            mProgressBar.setSmoothProgressDrawableColors(mContext.getResources().getIntArray(R.array.gplus_colors));
            mProgressBar.setSmoothProgressDrawableInterpolator(new FastOutSlowInInterpolator());   //进度条估值器
            mProgressBar.setSmoothProgressDrawableSectionsCount(8);   //进度条分段数
            mProgressBar.setSmoothProgressDrawableProgressiveStartSpeed(0.6f);
            mProgressBar.setSmoothProgressDrawableProgressiveStopSpeed(0.5f);
        }


        //升级按钮
        bt2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DownloadUtils.APK_DOWNLOAD_ID = DownloadUtils.downloadApk(mVersionBean.getData().getVersionNumberStr(),
                        mVersionBean.getData().getDownloadUrl(), getResources().getString(R.string.app_name) + ".apk");
                bt2.setVisibility(View.GONE);
                tv_next_time.setVisibility(View.GONE);
                mProgressBar.setVisibility(View.VISIBLE);
                mProgressBar.progressiveStart();
            }
        });

        //下次再说 点击事件
        tv_next_time.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                baseDialog.dismiss();
            }
        });

        //dialog消失
        baseDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface dialog) {
                //dialog消失后开始初始化界面
                initPage();
            }
        });

        baseDialog.setCancelable(false);
        baseDialog.show();
    }


    /**
     * 初始化界面
     */
    private void initPage() {

        //不用注册和登录就可以进入主页，然后在涉及个人操作时，再登录和注册
        startActivityToHome();
    }

    /**
     * 初始化底部指示器
     */
    private void initImageAndIndicator() {
        //banner轮播图
        //设置图片加载器
        imgs = new int[]{
                R.drawable.guide_page_one,
                R.drawable.guide_page_two,
                R.drawable.guide_page_three
        };
        imageViews = new ArrayList<>();
        ImageView imageView = null;
        View view = null;
        for (int i = 0; i < imgs.length; i++) {
            //引导页图片
            imageView = new ImageView(mContext);
            imageView.setScaleType(ImageView.ScaleType.FIT_XY);
            Glide.with(mContext).load(imgs[i]).into(imageView);
            //集合中添加引导页
            imageViews.add(imageView);

            //new出三个底部圆点指示器
            view = new View(mContext);
            LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(SizeUtils.dp2px(8), SizeUtils.dp2px(8));
            if (i != 0) {
                layoutParams.setMargins(SizeUtils.dp2px(10), 0, 0, 0);
            }
            view.setLayoutParams(layoutParams);
            view.setBackgroundResource(R.drawable.selector_launch_indicator);
            //线性布局内添加圆形指示器
            mLlLaunchIndicator.addView(view);
        }
        mLlLaunchIndicator.getChildAt(0).setSelected(true);

    }

    /**
     * 初始化引导页
     */
    private void initViewPager() {
        //设置引导页页数限制
        mVpLaunch.setOffscreenPageLimit(2);
        //设置引导页设置适配器
        mVpLaunch.setAdapter(new PagerAdapter() {
            @Override
            public int getCount() {
                return imageViews.size();
            }

            @Override
            public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
                return view == object;
            }

            @NonNull
            @Override
            public Object instantiateItem(@NonNull ViewGroup container, int position) {
                ImageView imageView = imageViews.get(position);
                container.addView(imageView);
                return imageView;
            }

            @Override
            public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
                container.removeView((View) object);
//                super.destroyItem(container, position, object);
            }
        });

        mVpLaunch.setCurrentItem(0);
        prePosition = 0;

        //引导页滑动监听
        mVpLaunch.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {

            }

            @Override
            public void onPageSelected(int position) {
                //指示器圆点显示
                mLlLaunchIndicator.getChildAt(prePosition).setSelected(false);
                mLlLaunchIndicator.getChildAt(position).setSelected(true);
                prePosition = position;

                //引导页最后一页，显示注册按钮，权限判断，版本判断
                if (position == imageViews.size() - 1) {
                    mBtnLaunch.setVisibility(View.VISIBLE);

                    //请求权限,包含电话权限（获取IMEI）
                    if (Build.VERSION.SDK_INT >= 23) {
                        requestPermission();
                    }

                } else {   //隐藏按钮
                    mBtnLaunch.setVisibility(View.GONE);
                }
            }

            @Override
            public void onPageScrollStateChanged(int state) {

            }
        });
        //登录按钮
        mBtnLaunch.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //第一次进入app，设置标记位为false
//                ZhenNiu.spUtils.put(Constants.IS_FIRST, false);

                //不用注册和登录就可以进入主页，然后在涉及个人操作时，再登录和注册
                Intent intent = new Intent(mContext, MainActivity.class);
                startActivity(intent);
            }
        });
    }


    /**
     * 是否登录
     *
     * @return
     */
    public boolean isLogin() {
        //为true，代表一直是登录状态
        return SPUtils.getInstance().getBoolean(Constants.IS_SIGN_IN, false);
    }


    /**
     * 则进入首页
     */
    private void startActivityToHome() {
        //延迟进入首页
        mHandler.postDelayed(new Runnable() {

            @Override
            public void run() {
                Intent intent = new Intent(mContext, WebviewActivity.class);
                intent.putExtra(Constants.URL, Constants.ZHEN_NIU_H5_URL);
                startActivity(intent);
                finish();
            }
        }, 2000);
    }


    @Override
    protected void onRestart() {
        super.onRestart();
        //如果拒绝某项权限，并且进入设置界面打开权限后，返回到app启动界面，如果没有initPage()方法，则会一直停留在此界面
        //但是onRestart()会在多种情况下被调用，所以要做限制，只有跳到设置界面返回后onRestart()方法被调用
        if (isSure) {
//            if (!ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true/*false*/)) {   // 非第一次使用APP，从设置权限页面回来后，会调用initPage（）
//                initPage();
//            }
            initPage();
            isSure = false;
        }
        //升级弹窗是否消失
        if (baseDialog != null) {
            if (isUpdateDismiss) {   //普通更新，从安装页退回
                baseDialog.dismiss();

            } else {   //强制更新，从安装页退回
                ((TextView) baseDialog.findViewById(R.id.tv_msg)).setText(getResources().getString(R.string.dialog_update_warn));
                bt2.setVisibility(View.VISIBLE);
                mProgressBar.setVisibility(View.GONE);
            }
        }
    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
        boolean visible = tDialog.isVisible();
    }

    /**
     * 可以使dialog消失，但无法退出启动页
     *
     * @param keyCode
     * @param event
     * @return
     */
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if ( keyCode == KeyEvent.KEYCODE_BACK /*&& !ZhenNiu.spUtils.getBoolean(Constants.IS_FIRST, true)*/) {
            return true;   //不执行父类点击事件
        }
        return super.onKeyDown(keyCode, event);   //继续执行父类其他点击事件
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        ZhenNiu.removeActivity(this);

        //解除eventbus
        if(EventBus.getDefault().isRegistered(this)) {
            EventBus.getDefault().unregister(this);
        }
    }
}
